1class LogLevel(Enum):
2    DEBUG = 1
3    INFO = 2
4    WARN = 3
5    ERROR = 4
6    FATAL = 5
7
8    def is_greater_or_equal(self, other: 'LogLevel') -> bool:
9        return self.value >= other.value

1class LogMessage:
2    def __init__(self, level: LogLevel, logger_name: str, message: str):
3        self.timestamp = datetime.now()
4        self.level = level
5        self.logger_name = logger_name
6        self.message = message
7        self.thread_name = threading.current_thread().name
8
9    def get_timestamp(self) -> datetime:
10        return self.timestamp
11
12    def get_level(self) -> LogLevel:
13        return self.level
14
15    def get_logger_name(self) -> str:
16        return self.logger_name
17
18    def get_thread_name(self) -> str:
19        return self.thread_name
20
21    def get_message(self) -> str:
22        return self.message

1class LogFormatter(ABC):
2    @abstractmethod
3    def format(self, log_message: LogMessage) -> str:
4        pass
5
6
7class SimpleTextFormatter(LogFormatter):
8    def format(self, log_message: LogMessage) -> str:
9        timestamp_str = log_message.get_timestamp().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
10        return f"{timestamp_str} [{log_message.get_thread_name()}] {log_message.get_level().name} - {log_message.get_logger_name()}: {log_message.get_message()}\n"

1class LogAppender(ABC):
2    @abstractmethod
3    def append(self, log_message: LogMessage):
4        pass
5
6    @abstractmethod
7    def close(self):
8        pass
9
10    @abstractmethod
11    def get_formatter(self) -> LogFormatter:
12        pass
13
14    @abstractmethod
15    def set_formatter(self, formatter: LogFormatter):
16        pass
17
18
19class ConsoleAppender(LogAppender):
20    def __init__(self):
21        self.formatter = SimpleTextFormatter()
22
23    def append(self, log_message: LogMessage):
24        print(self.formatter.format(log_message), end='')
25
26    def close(self):
27        pass
28
29    def set_formatter(self, formatter: LogFormatter):
30        self.formatter = formatter
31
32    def get_formatter(self) -> LogFormatter:
33        return self.formatter
34
35
36class FileAppender(LogAppender):
37    def __init__(self, file_path: str):
38        self.formatter = SimpleTextFormatter()
39        self._lock = threading.Lock()
40        try:
41            self.writer = open(file_path, 'a')
42        except Exception as e:
43            print(f"Failed to create writer for file logs, exception: {e}")
44            self.writer = None
45
46    def append(self, log_message: LogMessage):
47        with self._lock:
48            if self.writer:
49                try:
50                    self.writer.write(self.formatter.format(log_message) + "\n")
51                    self.writer.flush()
52                except Exception as e:
53                    print(f"Failed to write logs to file, exception: {e}")
54
55    def close(self):
56        if self.writer:
57            try:
58                self.writer.close()
59            except Exception as e:
60                print(f"Failed to close logs file, exception: {e}")
61
62    def set_formatter(self, formatter: LogFormatter):
63        self.formatter = formatter
64
65    def get_formatter(self) -> LogFormatter:
66        return self.formatter

1class AsyncLogProcessor:
2    def __init__(self):
3        self.executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="AsyncLogProcessor")
4        self.shutdown_flag = False
5
6    def process(self, log_message: LogMessage, appenders: List[LogAppender]):
7        if self.shutdown_flag:
8            print("Logger is shut down. Cannot process log message.", file=sys.stderr)
9            return
10
11        def process_task():
12            for appender in appenders:
13                appender.append(log_message)
14
15        self.executor.submit(process_task)
16
17    def stop(self):
18        self.shutdown_flag = True
19        self.executor.shutdown(wait=True, timeout=2)
20        if not self.executor._shutdown:
21            print("Logger executor did not terminate in the specified time.", file=sys.stderr)

1class LogManager:
2    _instance = None
3    _lock = threading.Lock()
4
5    def __init__(self):
6        if LogManager._instance is not None:
7            raise Exception("This class is a singleton!")
8        self.loggers: Dict[str, 'Logger'] = {}
9        self.root_logger = Logger("root", None)
10        self.loggers["root"] = self.root_logger
11        self.processor = AsyncLogProcessor()
12
13    @staticmethod
14    def get_instance():
15        if LogManager._instance is None:
16            with LogManager._lock:
17                if LogManager._instance is None:
18                    LogManager._instance = LogManager()
19        return LogManager._instance
20
21    def get_logger(self, name: str) -> 'Logger':
22        if name not in self.loggers:
23            self.loggers[name] = self._create_logger(name)
24        return self.loggers[name]
25
26    def _create_logger(self, name: str) -> 'Logger':
27        if name == "root":
28            return self.root_logger
29        
30        last_dot = name.rfind('.')
31        parent_name = "root" if last_dot == -1 else name[:last_dot]
32        parent = self.get_logger(parent_name)
33        return Logger(name, parent)
34
35    def get_root_logger(self) -> 'Logger':
36        return self.root_logger
37
38    def get_processor(self) -> AsyncLogProcessor:
39        return self.processor
40
41    def shutdown(self):
42        # Stop the processor first to ensure all logs are written
43        self.processor.stop()
44
45        # Then, close all appenders
46        all_appenders = set()
47        for logger in self.loggers.values():
48            for appender in logger.get_appenders():
49                all_appenders.add(appender)
50        
51        for appender in all_appenders:
52            appender.close()
53        
54        print("Logging framework shut down gracefully.")

1class Logger:
2    def __init__(self, name: str, parent: Optional['Logger']):
3        self.name = name
4        self.level: Optional[LogLevel] = None
5        self.parent = parent
6        self.appenders: List[LogAppender] = []
7        self.additivity = True
8
9    def add_appender(self, appender: LogAppender):
10        self.appenders.append(appender)
11
12    def get_appenders(self) -> List[LogAppender]:
13        return self.appenders
14
15    def set_level(self, min_level: LogLevel):
16        self.level = min_level
17
18    def set_additivity(self, additivity: bool):
19        self.additivity = additivity
20
21    def get_effective_level(self) -> LogLevel:
22        logger = self
23        while logger is not None:
24            current_level = logger.level
25            if current_level is not None:
26                return current_level
27            logger = logger.parent
28        return LogLevel.DEBUG  # Default root level
29
30    def log(self, message_level: LogLevel, message: str):
31        if message_level.is_greater_or_equal(self.get_effective_level()):
32            log_message = LogMessage(message_level, self.name, message)
33            self._call_appenders(log_message)
34
35    def _call_appenders(self, log_message: LogMessage):
36        if self.appenders:
37            LogManager.get_instance().get_processor().process(log_message, self.appenders)
38        
39        if self.additivity and self.parent is not None:
40            self.parent._call_appenders(log_message)
41
42    def debug(self, message: str):
43        self.log(LogLevel.DEBUG, message)
44
45    def info(self, message: str):
46        self.log(LogLevel.INFO, message)
47
48    def warn(self, message: str):
49        self.log(LogLevel.WARN, message)
50
51    def error(self, message: str):
52        self.log(LogLevel.ERROR, message)
53
54    def fatal(self, message: str):
55        self.log(LogLevel.FATAL, message)

1class LoggingFrameworkDemo:
2    @staticmethod
3    def main():
4        # --- 1. Initial Configuration ---
5        log_manager = LogManager.get_instance()
6        root_logger = log_manager.get_root_logger()
7        root_logger.set_level(LogLevel.INFO)  # Set global minimum level to INFO
8
9        # Add a console appender to the root logger
10        root_logger.add_appender(ConsoleAppender())
11
12        print("--- Initial Logging Demo ---")
13        main_logger = log_manager.get_logger("com.example.Main")
14        main_logger.info("Application starting up.")
15        main_logger.debug("This is a debug message, it should NOT appear.")  # Below root level
16        main_logger.warn("This is a warning message.")
17
18        # --- 2. Hierarchy and Additivity Demo ---
19        print("\n--- Logger Hierarchy Demo ---")
20        db_logger = log_manager.get_logger("com.example.db")
21        # db_logger inherits level and appenders from root
22        db_logger.info("Database connection pool initializing.")
23
24        # Let's create a more specific logger and override its level
25        service_logger = log_manager.get_logger("com.example.service.UserService")
26        service_logger.set_level(LogLevel.DEBUG)  # More verbose logging for this specific service
27        service_logger.info("User service starting.")
28        service_logger.debug("This debug message SHOULD now appear for the service logger.")
29
30        # --- 3. Dynamic Configuration Change ---
31        print("\n--- Dynamic Configuration Demo ---")
32        print("Changing root log level to DEBUG...")
33        root_logger.set_level(LogLevel.DEBUG)
34        main_logger.debug("This debug message should now be visible.")
35
36        try:
37            time.sleep(0.5)
38            log_manager.shutdown()
39        except Exception as e:
40            print("Caught exception")
41
42if __name__ == "__main__":
43    LoggingFrameworkDemo.main()